{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "98c82af2",
   "metadata": {},
   "source": [
    "这个Notebook是[The Annotated Transformer](https://nlp.seas.harvard.edu/annotated-transformer/)和cs231n的学习笔记.\n",
    "\n",
    "![alt text](resources/transformer_arch.png \"Title\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3640316c",
   "metadata": {},
   "source": [
    "###  多头注意力机制实现\n",
    "下面这段介绍是从cs231n作业上抄下来的多头注意力机制详细的描述\n",
    "#### Dot-Product Attention\n",
    "\n",
    "Recall that attention can be viewed as an operation on a query $q\\in\\mathbb{R}^d$, a set of value vectors $\\{v_1,\\dots,v_n\\}, v_i\\in\\mathbb{R}^d$, and a set of key vectors $\\{k_1,\\dots,k_n\\}, k_i \\in \\mathbb{R}^d$, specified as\n",
    "\n",
    "\\begin{align}\n",
    "c = \\sum_{i=1}^{n} v_i \\alpha_i, &\\ \\ \\ \\alpha_i = \\frac{\\exp(k_i^\\top q)}{\\sum_{j=1}^{n} \\exp(k_j^\\top q)} \\\\\n",
    "\\end{align}\n",
    "\n",
    "where $\\alpha_i$ are frequently called the \"attention weights\", and the output $c\\in\\mathbb{R}^d$ is a correspondingly weighted average over the value vectors.\n",
    "\n",
    "#### Self-Attention\n",
    "In Transformers, we perform self-attention, which means that the values, keys and query are derived from the input $X \\in \\mathbb{R}^{\\ell \\times d}$, where $\\ell$ is our sequence length. Specifically, we learn parameter matrices $V,K,Q \\in \\mathbb{R}^{d\\times d}$ to map our input $X$ as follows:\n",
    "\n",
    "\\begin{align}\n",
    "v_i = Vx_i\\ \\ i \\in \\{1,\\dots,\\ell\\}\\\\\n",
    "k_i = Kx_i\\ \\ i \\in \\{1,\\dots,\\ell\\}\\\\\n",
    "q_i = Qx_i\\ \\ i \\in \\{1,\\dots,\\ell\\}\n",
    "\\end{align}\n",
    "\n",
    "#### Multi-Headed Scaled Dot-Product Attention\n",
    "In the case of multi-headed attention, we learn a parameter matrix for each head, which gives the model more expressivity to attend to different parts of the input. Let $h$ be number of heads, and $Y_i$ be the attention output of head $i$. Thus we learn individual matrices $Q_i$, $K_i$ and $V_i$. To keep our overall computation the same as the single-headed case, we choose $Q_i \\in \\mathbb{R}^{d\\times d/h}$, $K_i \\in \\mathbb{R}^{d\\times d/h}$ and $V_i \\in \\mathbb{R}^{d\\times d/h}$. Adding in a scaling term $\\frac{1}{\\sqrt{d/h}}$ to our simple dot-product attention above, we have\n",
    "\n",
    "\\begin{equation}\n",
    "Y_i = \\text{softmax}\\bigg(\\frac{(XQ_i)(XK_i)^\\top}{\\sqrt{d/h}}\\bigg)(XV_i)\n",
    "\\end{equation}\n",
    "\n",
    "where $Y_i\\in\\mathbb{R}^{\\ell \\times d/h}$, where $\\ell$ is our sequence length.\n",
    "\n",
    "In our implementation, we apply dropout to the attention weights (though in practice it could be used at any step):\n",
    "\n",
    "\\begin{equation}\n",
    "Y_i = \\text{dropout}\\bigg(\\text{softmax}\\bigg(\\frac{(XQ_i)(XK_i)^\\top}{\\sqrt{d/h}}\\bigg)\\bigg)(XV_i)\n",
    "\\end{equation}\n",
    "\n",
    "Finally, then the output of the self-attention is a linear transformation of the concatenation of the heads:\n",
    "\n",
    "\\begin{equation}\n",
    "Y = [Y_1;\\dots;Y_h]A\n",
    "\\end{equation}\n",
    "\n",
    "were $A \\in\\mathbb{R}^{d\\times d}$ and $[Y_1;\\dots;Y_h]\\in\\mathbb{R}^{\\ell \\times d}$."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c8ed01f9",
   "metadata": {},
   "source": [
    "多头注意力机制的计算流程图\n",
    "\n",
    "![alt text](resources/multiheadattention.png \"Title\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "fc2bc3ca",
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import math\n",
    "from torch import Tensor\n",
    "from typing import Optional\n",
    "\n",
    "\n",
    "class MultiHeadAttention(nn.Module):\n",
    "    def __init__(self, embed_dim: int, num_heads: int, dropout: float = 0.1) -> None:\n",
    "        \"\"\"简单的多头注意力实现,主要来自我的cs231n的作业.\n",
    "\n",
    "        Args:\n",
    "            embed_dim: Dimension of the token embedding.\n",
    "            num_heads: Number of attention heads.\n",
    "            dropout: Dropout probability. Defaults to 0.1.\n",
    "        \"\"\"\n",
    "        super().__init__()\n",
    "        assert embed_dim % num_heads == 0\n",
    "\n",
    "        self.n_heads = num_heads\n",
    "        self.embed_dim = embed_dim\n",
    "        self.head_dim = embed_dim // num_heads\n",
    "\n",
    "        self.key_project = nn.Linear(embed_dim, embed_dim)\n",
    "        self.query_project = nn.Linear(embed_dim, embed_dim)\n",
    "        self.value_project = nn.Linear(embed_dim, embed_dim)\n",
    "        self.output_project = nn.Linear(embed_dim, embed_dim)\n",
    "        self.drop = nn.Dropout(dropout)\n",
    "\n",
    "    def forward(\n",
    "        self,\n",
    "        query: Tensor,\n",
    "        key: Tensor,\n",
    "        value: Tensor,\n",
    "        atten_mask: Optional[Tensor] = None,\n",
    "    ) -> Tensor:\n",
    "        \"\"\"\n",
    "        Calculate the masked attention output for the provided data, computing\n",
    "        all attention heads in parallel.\n",
    "\n",
    "        In the shape definitions below, N is the batch size, S is the source\n",
    "        sequence length, T is the target sequence length, and E is the embedding\n",
    "        dimension.\n",
    "\n",
    "        Args:\n",
    "            query: Input data to be used as the query, of shape (N, S, E)\n",
    "            key: Input data to be used as the key, of shape (N, T, E)\n",
    "            value: Input data to be used as the value, of shape (N, T, E)\n",
    "            atten_mask: Array of shape (S, T) where mask[i,j] == 0 indicates token\n",
    "                        i in the source should not influence token j in the target.\n",
    "\n",
    "        Returns:\n",
    "            output: Tensor of shape (N, S, E) giving the weighted combination of\n",
    "                    data in value according to the attention weights calculated using key\n",
    "                    and query.\n",
    "        \"\"\"\n",
    "        N, S, E = query.shape\n",
    "        N, T, E = value.shape\n",
    "        # Perform input projection\n",
    "        query = (\n",
    "            self.query_project(query)\n",
    "            .contiguous()\n",
    "            .view(N, S, self.n_heads, self.head_dim)\n",
    "        )\n",
    "        key = self.key_project(key).contiguous().view(N, T, self.n_heads, self.head_dim)\n",
    "        value = (\n",
    "            self.value_project(value)\n",
    "            .contiguous()\n",
    "            .view(N, T, self.n_heads, self.head_dim)\n",
    "        )\n",
    "\n",
    "        # 将注意力的维度挪到batch维度之后\n",
    "        query = query.transpose(1, 2)  # shape (N,H,S,HD)\n",
    "        key = key.transpose(1, 2)  # shape (N,H,T,HD)\n",
    "        value = value.transpose(1, 2)  # shape (N,H,T,HD)\n",
    "\n",
    "        # compute dot product between query and key\n",
    "        # query shape (N,H,S,HD)\n",
    "        # key shape (N,H,T,HD)\n",
    "        # to do matmul, we should transpose key to (N,H,HD,T)\n",
    "        logits = torch.matmul(query, key.transpose(-2, -1)) / math.sqrt(\n",
    "            self.head_dim\n",
    "        )  # shape (N,H,S,T)\n",
    "        if atten_mask is not None:\n",
    "            # 将需要屏蔽的位置替换为非常小的数值\n",
    "            logits.masked_fill_(atten_mask == 0.0, -1e9)\n",
    "        atten_weight = self.drop(logits.softmax(-1))  # shape (N,H,S,T)\n",
    "\n",
    "        Y = torch.matmul(atten_weight, value)  # shape (N,H,S,HD)\n",
    "        Y = Y.transpose(1, 2)  # shape (N,S,H,HD)\n",
    "        Y = Y.contiguous().view(N, S, E)  # shape (N,S,E)\n",
    "        return self.output_project(Y)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a2d99151",
   "metadata": {},
   "source": [
    "### Positional Encoding\n",
    "\n",
    "While transformers are able to easily attend to any part of their input, the attention mechanism has no concept of token order. However, for many tasks (especially natural language processing), relative token order is very important. To recover this, the authors add a positional encoding to the embeddings of individual word tokens.\n",
    "\n",
    "Let us define a matrix $P \\in \\mathbb{R}^{l\\times d}$, where $P_{ij} = $\n",
    "\n",
    "$$\n",
    "\\begin{cases}\n",
    "\\text{sin}\\left(i \\cdot 10000^{-\\frac{j}{d}}\\right) & \\text{if j is even} \\\\\n",
    "\\text{cos}\\left(i \\cdot 10000^{-\\frac{(j-1)}{d}}\\right) & \\text{otherwise} \\\\\n",
    "\\end{cases}\n",
    "$$\n",
    "\n",
    "Rather than directly passing an input $X \\in \\mathbb{R}^{l\\times d}$ to our network, we instead pass $X + P$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "b62b455f",
   "metadata": {},
   "outputs": [],
   "source": [
    "class PositionalEncoding(nn.Module):\n",
    "    \"\"\"\n",
    "    Encodes information about the positions of the tokens in the sequence. In\n",
    "    this case, the layer has no learnable parameters, since it is a simple\n",
    "    function of sines and cosines.\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(\n",
    "        self, embed_dim: int, dropout: float = 0.1, max_len: int = 5000\n",
    "    ) -> None:\n",
    "        \"\"\"\n",
    "        Construct the PositionalEncoding layer.\n",
    "\n",
    "        Inputs:\n",
    "         - embed_dim: the size of the embed dimension\n",
    "         - dropout: the dropout value\n",
    "         - max_len: the maximum possible length of the incoming sequence\n",
    "        \"\"\"\n",
    "        super(PositionalEncoding, self).__init__()\n",
    "        self.dropout = nn.Dropout(p=dropout)\n",
    "\n",
    "        # Compute the positional encodings once in log space.\n",
    "        pe = torch.zeros(max_len, embed_dim)\n",
    "        position = torch.arange(0, max_len).unsqueeze(1)\n",
    "        div_term = torch.exp(\n",
    "            torch.arange(0, embed_dim, 2) * -(math.log(10000.0) / embed_dim)\n",
    "        )\n",
    "        pe[:, 0::2] = torch.sin(position * div_term)\n",
    "        pe[:, 1::2] = torch.cos(position * div_term)\n",
    "        pe = pe.unsqueeze(0)\n",
    "        self.register_buffer(\"pe\", pe)\n",
    "\n",
    "    def forward(self, x: Tensor) -> Tensor:\n",
    "        \"\"\"\n",
    "        Element-wise add positional embeddings to the input sequence.\n",
    "\n",
    "        Inputs:\n",
    "            x: the sequence fed to the positional encoder model, of shape\n",
    "               (N, S, D), where N is the batch size, S is the sequence length and\n",
    "                D is embed dim.\n",
    "        Returns:\n",
    "            output: the input sequence + positional encodings, of shape (N, S, D).\n",
    "        \"\"\"\n",
    "        N, S, D = x.shape\n",
    "        output = self.dropout(self.pe[:, :S, :] + x)\n",
    "        return output\n",
    "\n",
    "\n",
    "def subsequent_mask(size: int):\n",
    "    \"\"\"Mask out subsequent positions.\"\"\"\n",
    "    attn_shape = (1, size, size)\n",
    "    subsequent_mask = torch.triu(torch.ones(attn_shape), diagonal=1).type(torch.uint8)\n",
    "    return subsequent_mask == 0"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "53498fd9",
   "metadata": {},
   "source": [
    "可视化Positional Embedding"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "01a690d7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x71cd965af4d0>"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "PE = PositionalEncoding(512, 0.1)\n",
    "plt.imshow(PE.pe.squeeze()[:100, :].numpy())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6375a7f7",
   "metadata": {},
   "source": [
    "### Position-wise Feedforward Network\n",
    "![alt text](resources/positionwise_mlp.png \"Title\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "76c6cfc2",
   "metadata": {},
   "outputs": [],
   "source": [
    "class PositionWiseMLP(nn.Sequential):\n",
    "    def __init__(self, embed_dim: int, diff_dim: int, dropout: float) -> None:\n",
    "        layers = [\n",
    "            nn.Linear(embed_dim, diff_dim),\n",
    "            nn.ReLU(),\n",
    "            nn.Dropout(dropout),\n",
    "            nn.Linear(diff_dim, embed_dim),\n",
    "        ]\n",
    "        super().__init__(*layers)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9fe284e1",
   "metadata": {},
   "source": [
    "### Sublayer架构\n",
    "\n",
    "#### Transformer中Post-Norm与Pre-Norm的对比分析\n",
    "\n",
    "在Transformer架构中，**Post-Norm**（后归一化）和**Pre-Norm**（前归一化）是层归一化（Layer Normalization）相对于残差连接的两种不同放置策略，显著影响模型训练和性能。\n",
    "\n",
    "##### 1. Post-Norm（原始Transformer设计）\n",
    "**结构公式**：`Output = LN(x + Sublayer(x))`  \n",
    "\n",
    "###### ✅ 优点\n",
    "- **输出稳定**：每层输出强制归一化，缓解内部协变量偏移\n",
    "- **理论一致性**：符合原始Transformer论文设计（Vaswani et al., 2017）\n",
    "\n",
    "###### ❌ 缺点\n",
    "- **训练不稳定**：深层模型易出现梯度消失/爆炸\n",
    "- **依赖Warm-up**：需配合学习率预热策略\n",
    "- **收敛速度慢**：通常需要更多训练步数\n",
    "\n",
    "##### 2. Pre-Norm（现代主流设计）\n",
    "**结构公式**：`Output = x + Sublayer(LN(x))`  \n",
    "###### ✅ 优点\n",
    "- **训练稳定**：梯度可通过恒等映射直接回传（缓解梯度消失）\n",
    "- **收敛速度快**：通常减少30-50%训练步数\n",
    "- **无需Warm-up**：降低优化策略复杂度\n",
    "- **支持深层模型**：百层以上Transformer的可行方案\n",
    "\n",
    "###### ❌ 缺点\n",
    "- **输出范围变化**：激活值随网络深度递增\n",
    "- **理论性能上限**：可能略低于Post-Norm（实际少见）\n",
    "\n",
    "##### 3. 关键特性对比\n",
    "| 特性                | Post-Norm                  | Pre-Norm                   |\n",
    "|---------------------|----------------------------|----------------------------|\n",
    "| **训练稳定性**      | 差（深层梯度问题严重）     | 优（梯度有\"捷径\"）         |\n",
    "| **收敛速度**        | 慢                         | 快                         |\n",
    "| **Warm-up依赖**     | 强依赖                     | 基本不需要                 |\n",
    "| **输出分布**        | 每层严格归一化             | 随深度递增                 |\n",
    "| **千层模型支持**    | 不可行                     | 可行                       |\n",
    "| **代表模型**        | 原始Transformer            | GPT系列、BERT、LLaMA、T5等 |\n",
    "\n",
    "##### 4. 实际应用建议\n",
    "- **深层模型（≥12层）**：优先使用Pre-Norm（现代大模型标配）\n",
    "- **浅层模型（<12层）**：两者均可尝试，Post-Norm可能有轻微优势\n",
    "- **百亿参数级模型**：推荐Pre-Norm变体（如DeepNorm）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "27093bfc",
   "metadata": {},
   "outputs": [],
   "source": [
    "class SublayerConnection(nn.Module):\n",
    "    def __init__(self, embed_dim: int, dropout: float, post_norm: bool = False) -> None:\n",
    "        \"\"\"Sublayer module.\n",
    "\n",
    "        Args:\n",
    "            embed_dim: Input feature size.\n",
    "            dropout: dropout ratio.\n",
    "            post_norm: Whether to use post-norm or pre-norm architecture.\n",
    "                       关于\n",
    "                       see: https://zhuanlan.zhihu.com/p/480783670\n",
    "                            https://arxiv.org/pdf/2002.04745\n",
    "        \"\"\"\n",
    "        super().__init__()\n",
    "        self.ln = nn.LayerNorm(embed_dim)\n",
    "        self.dropout = nn.Dropout(dropout)\n",
    "        self.post_norm = post_norm\n",
    "\n",
    "    def forward(self, x: Tensor, sublayer: nn.Module) -> Tensor:\n",
    "        if self.post_norm:\n",
    "            return self.ln(x + self.dropout(sublayer(x)))\n",
    "        else:\n",
    "            return x + self.dropout(sublayer(self.ln(x)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bc5a6f73",
   "metadata": {},
   "source": [
    "### Encoder"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "0240dc63",
   "metadata": {},
   "outputs": [],
   "source": [
    "import copy\n",
    "\n",
    "from torch.nn import ModuleList\n",
    "\n",
    "\n",
    "def clones(module, N) -> ModuleList:\n",
    "    \"\"\"Produce N identical layers.\"\"\"\n",
    "    return nn.ModuleList([copy.deepcopy(module) for _ in range(N)])\n",
    "\n",
    "\n",
    "class EncoderLayer(nn.Module):\n",
    "    def __init__(\n",
    "        self, embed_dim: int, n_heads: int, diff_dim: int, dropout: float\n",
    "    ) -> None:\n",
    "        super().__init__()\n",
    "        # self attention\n",
    "        self.self_atten = MultiHeadAttention(embed_dim, n_heads, dropout)\n",
    "        self.sublayer_1 = SublayerConnection(embed_dim, dropout)\n",
    "        self.mlp = PositionWiseMLP(embed_dim, diff_dim, dropout)\n",
    "        self.sublayer_2 = SublayerConnection(embed_dim, dropout)\n",
    "\n",
    "    def forward(self, x: Tensor):\n",
    "        x = self.sublayer_1(x, lambda x: self.self_atten(x, x, x))\n",
    "        x = self.sublayer_2(x, self.mlp)\n",
    "        return x\n",
    "\n",
    "\n",
    "class Encoder(nn.Sequential):\n",
    "    def __init__(\n",
    "        self,\n",
    "        embed_dim: int,\n",
    "        n_heads: int,\n",
    "        diff_dim: int,\n",
    "        dropout: float,\n",
    "        num_layers: int,\n",
    "    ) -> None:\n",
    "        layers = [\n",
    "            EncoderLayer(embed_dim, n_heads, diff_dim, dropout)\n",
    "            for _ in range(num_layers)\n",
    "        ]\n",
    "        super().__init__(*layers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "eeb225b8",
   "metadata": {},
   "outputs": [],
   "source": [
    "encoder = Encoder(\n",
    "    embed_dim=55,\n",
    "    n_heads=5,\n",
    "    diff_dim=77,\n",
    "    dropout=0,\n",
    "    num_layers=2,\n",
    ")\n",
    "result = encoder(torch.ones(10, 12, 55))\n",
    "assert result.shape == (10, 12, 55)\n",
    "assert torch.all(result[0] - result[9]) < 1e-6\n",
    "assert torch.all(result[0][0] - result[0][1]) < 1e-6"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3b31c9a6",
   "metadata": {},
   "source": [
    "### Decoder"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "061fa820",
   "metadata": {},
   "outputs": [],
   "source": [
    "class DecoderLayer(nn.Module):\n",
    "    \"Encoder is made up of self-attn and feed forward (defined below)\"\n",
    "\n",
    "    def __init__(\n",
    "        self, embed_dim: int, n_heads: int, diff_dim: int, dropout: float\n",
    "    ) -> None:\n",
    "        super().__init__()\n",
    "        # self attention\n",
    "        self.self_atten = MultiHeadAttention(embed_dim, n_heads, dropout)\n",
    "        self.sublayer_1 = SublayerConnection(embed_dim, dropout)\n",
    "        # source attention\n",
    "        self.src_atten = MultiHeadAttention(embed_dim, n_heads, dropout)\n",
    "        self.sublayer_2 = SublayerConnection(embed_dim, dropout)\n",
    "        self.mlp = PositionWiseMLP(embed_dim, diff_dim, dropout)\n",
    "        self.sublayer_3 = SublayerConnection(embed_dim, dropout)\n",
    "\n",
    "    def forward(self, x: Tensor, memory: Tensor, mask: Tensor) -> Tensor:\n",
    "        \"\"\"_summary_\n",
    "\n",
    "        Args:\n",
    "            x: Decoder sequence of shape (N,T,E)\n",
    "            memory: Encoder sequence of shape (N,S,E)\n",
    "            mask: Decoder sequence mask\n",
    "\n",
    "        Returns:\n",
    "            _description_\n",
    "        \"\"\"\n",
    "        x = self.sublayer_1(x, lambda x: self.self_atten(x, x, x, mask))\n",
    "        x = self.sublayer_3(x, lambda x: self.src_atten(x, memory, memory))\n",
    "        x = self.sublayer_3(x, self.mlp)\n",
    "        return x\n",
    "\n",
    "\n",
    "class Decoder(nn.Module):\n",
    "    def __init__(\n",
    "        self,\n",
    "        embed_dim: int,\n",
    "        n_heads: int,\n",
    "        diff_dim: int,\n",
    "        dropout: float,\n",
    "        num_layers: int,\n",
    "    ) -> None:\n",
    "        super().__init__()\n",
    "        self.layers = nn.ModuleList(\n",
    "            [\n",
    "                DecoderLayer(embed_dim, n_heads, diff_dim, dropout)\n",
    "                for _ in range(num_layers)\n",
    "            ]\n",
    "        )\n",
    "\n",
    "    def forward(self, x: Tensor, memory: Tensor, mask: Tensor) -> Tensor:\n",
    "        for layer in self.layers:\n",
    "            x = layer(x, memory, mask)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c8a1f215",
   "metadata": {},
   "source": [
    "### Embedding Layer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "5e8db66e",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Embeddings(nn.Module):\n",
    "    def __init__(self, embed_dim: int, vocab_size: int) -> None:\n",
    "        super().__init__()\n",
    "        self.lut = nn.Embedding(vocab_size, embed_dim)\n",
    "        self.embed_dim = embed_dim\n",
    "\n",
    "    def forward(self, x: Tensor) -> Tensor:\n",
    "        return self.lut(x) * math.sqrt(self.embed_dim)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "14481795",
   "metadata": {},
   "source": [
    "### Transformer Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "eb426182",
   "metadata": {},
   "outputs": [],
   "source": [
    "from turtle import position\n",
    "from altair import Position\n",
    "from torch._tensor import Tensor\n",
    "\n",
    "\n",
    "class EncoderDecoder(nn.Module):\n",
    "    \"\"\"\n",
    "    A standard Encoder-Decoder architecture. Base for this and many\n",
    "    other models.\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, encoder, decoder, src_embed, tgt_embed, generator):\n",
    "        super().__init__()\n",
    "        self.encoder = encoder\n",
    "        self.decoder = decoder\n",
    "        self.src_embed = src_embed\n",
    "        self.tgt_embed = tgt_embed\n",
    "        self.generator = generator\n",
    "\n",
    "    def forward(self, src, tgt, tgt_mask):\n",
    "        \"Take in and process masked src and target sequences.\"\n",
    "        return self.decode(self.encode(src), tgt, tgt_mask)\n",
    "\n",
    "    def encode(self, src):\n",
    "        return self.encoder(self.src_embed(src))\n",
    "\n",
    "    def decode(self, memory, tgt, tgt_mask):\n",
    "        return self.decoder(self.tgt_embed(tgt), memory, tgt_mask)\n",
    "\n",
    "\n",
    "class Generator(nn.Module):\n",
    "    \"Define standard linear + softmax generation step.\"\n",
    "\n",
    "    def __init__(self, embed_dim, vocab_size) -> None:\n",
    "        super(Generator, self).__init__()\n",
    "        self.proj = nn.Linear(embed_dim, vocab_size)\n",
    "\n",
    "    def forward(self, x: Tensor) -> Tensor:\n",
    "        return nn.functional.log_softmax(self.proj(x), dim=-1)\n",
    "\n",
    "\n",
    "def make_model(\n",
    "    src_vocab_size: int,\n",
    "    tgt_vocab_size: int,\n",
    "    num_layers: int = 6,\n",
    "    embed_dim: int = 512,\n",
    "    diff_dim: int = 2048,\n",
    "    n_heads=8,\n",
    "    dropout=0.1,\n",
    ") -> EncoderDecoder:\n",
    "    encoder = Encoder(embed_dim, n_heads, diff_dim, dropout, num_layers)\n",
    "    decoder = Decoder(embed_dim, n_heads, diff_dim, dropout, num_layers)\n",
    "    position_encoding = PositionalEncoding(embed_dim, dropout)\n",
    "    model = EncoderDecoder(\n",
    "        encoder,\n",
    "        decoder,\n",
    "        nn.Sequential(Embeddings(embed_dim, src_vocab_size), position_encoding),\n",
    "        nn.Sequential(Embeddings(embed_dim, tgt_vocab_size), position_encoding),\n",
    "        Generator(embed_dim, tgt_vocab_size),\n",
    "    )\n",
    "    # This was important from their code.\n",
    "    # Initialize parameters with Glorot / fan_avg.\n",
    "    # 这个初始化方法会让ViT不稳定,建议乘以0.1\n",
    "    for p in model.parameters():\n",
    "        if p.dim() > 1:\n",
    "            nn.init.xavier_uniform_(p)\n",
    "    return model"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cac699bb",
   "metadata": {},
   "source": [
    "# Run inference test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "93cb554e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Example Untrained Model Prediction: tensor([[ 0, 15, 15, 15, 15, 70, 15, 70, 15, 18, 70, 70, 70, 70, 70, 70]])\n",
      "Example Untrained Model Prediction: tensor([[ 0, 78, 70, 78, 70, 78, 70, 78, 70, 78, 70, 78, 70, 78, 70, 78]])\n",
      "Example Untrained Model Prediction: tensor([[ 0,  1, 18, 48, 46, 63, 64, 43, 66, 66, 66, 95, 18, 48, 66, 18]])\n",
      "Example Untrained Model Prediction: tensor([[ 0, 38, 38, 38, 38, 38, 38, 33, 27, 51, 27, 27, 51, 51, 51, 51]])\n",
      "Example Untrained Model Prediction: tensor([[ 0, 82, 39, 26, 74, 82, 39, 26, 67, 74, 82, 39, 57, 56,  4, 87]])\n",
      "Example Untrained Model Prediction: tensor([[ 0, 94, 90, 54, 90,  4, 90,  4, 90,  4, 90,  4, 90,  4,  4,  4]])\n",
      "Example Untrained Model Prediction: tensor([[ 0, 94,  3, 42, 58, 58, 58, 58, 53, 66, 91, 60,  3, 42, 58, 21]])\n",
      "Example Untrained Model Prediction: tensor([[ 0, 95,  0, 58, 70, 58, 70, 58, 70, 58, 67, 36,  1, 58, 78, 36]])\n",
      "Example Untrained Model Prediction: tensor([[ 0, 89, 48, 93, 66, 90, 21, 72, 72, 72, 72, 72, 72, 72, 72, 72]])\n",
      "Example Untrained Model Prediction: tensor([[ 0, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59]])\n"
     ]
    }
   ],
   "source": [
    "def inference_test():\n",
    "    test_model = make_model(11, 100, 2)\n",
    "    test_model.eval()\n",
    "    src = torch.LongTensor([[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]])\n",
    "\n",
    "    memory = test_model.encode(src)\n",
    "    ys = torch.zeros(1, 1).type_as(src)\n",
    "\n",
    "    for i in range(15):\n",
    "        out = test_model.decode(\n",
    "            memory, ys, subsequent_mask(ys.size(1)).type_as(src.data)\n",
    "        )\n",
    "        prob = test_model.generator(out[:, -1])\n",
    "        _, next_word = torch.max(prob, dim=1)\n",
    "        next_word = next_word.data[0]\n",
    "        ys = torch.cat(\n",
    "            [ys, torch.empty(1, 1).type_as(src.data).fill_(next_word)], dim=1\n",
    "        )\n",
    "\n",
    "    print(\"Example Untrained Model Prediction:\", ys)\n",
    "\n",
    "\n",
    "def run_tests():\n",
    "    for _ in range(10):\n",
    "        inference_test()\n",
    "\n",
    "\n",
    "run_tests()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f4a57c66",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3eddd2be",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1edd3ce8",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "pytorch-cu124",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
